home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Add-Ons / MPW / MPW re2c 1.1 / examples / modula.re < prev    next >
Encoding:
Text File  |  1995-06-01  |  4.7 KB  |  203 lines  |  [TEXT/MPS ]
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. typedef unsigned int uint;
  6. typedef unsigned char uchar;
  7.  
  8. #define    BSIZE    8192
  9.  
  10. #define    YYCTYPE        uchar
  11. #define    YYCURSOR    cursor
  12. #define    YYLIMIT        s->lim
  13. #define    YYMARKER    s->ptr
  14. #define    YYFILL        {cursor = fill(s, cursor);}
  15.  
  16. #define    RETURN(i)    {s->cur = cursor; return i;}
  17.  
  18. typedef struct Scanner {
  19.     int            fd;
  20.     uchar        *bot, *tok, *ptr, *cur, *pos, *lim, *top, *eof;
  21.     uint        line;
  22. } Scanner;
  23.  
  24. uchar *fill(Scanner *s, uchar *cursor){
  25.     if(!s->eof){
  26.     uint cnt = s->tok - s->bot;
  27.     if(cnt){
  28.         memcpy(s->bot, s->tok, s->lim - s->tok);
  29.         s->tok = s->bot;
  30.         s->ptr -= cnt;
  31.         cursor -= cnt;
  32.         s->pos -= cnt;
  33.         s->lim -= cnt;
  34.     }
  35.     if((s->top - s->lim) < BSIZE){
  36.         uchar *buf = (uchar*) malloc(((s->lim - s->bot) + BSIZE)*sizeof(uchar));
  37.         memcpy(buf, s->tok, s->lim - s->tok);
  38.         s->tok = buf;
  39.         s->ptr = &buf[s->ptr - s->bot];
  40.         cursor = &buf[cursor - s->bot];
  41.         s->pos = &buf[s->pos - s->bot];
  42.         s->lim = &buf[s->lim - s->bot];
  43.         s->top = &s->lim[BSIZE];
  44.         free(s->bot);
  45.         s->bot = buf;
  46.     }
  47.     if((cnt = read(s->fd, (char*) s->lim, BSIZE)) != BSIZE){
  48.         s->eof = &s->lim[cnt]; *(s->eof)++ = '\n';
  49.     }
  50.     s->lim += cnt;
  51.     }
  52.     return cursor;
  53. }
  54.  
  55. int scan(Scanner *s){
  56.     uchar *cursor = s->cur;
  57.     uint depth;
  58. std:
  59.     s->tok = cursor;
  60. /*!re2c
  61. any    = [\000-\377];
  62. digit    = [0-9];
  63. letter    = [a-zA-Z];
  64. */
  65.  
  66. /*!re2c
  67.     "(*"            { depth = 1; goto comment; }
  68.  
  69.     digit +            {RETURN(1);}
  70.     digit + / ".."       {RETURN(1);}
  71.     [0-7] + "B"            {RETURN(2);}
  72.     [0-7] + "C"            {RETURN(3);}
  73.     digit [0-9A-F] * "H"    {RETURN(4);}
  74.     digit + "." digit * ("E" ([+-]) ? digit +) ?    {RETURN(5);}
  75.     ['] (any\[\n']) * [']    | ["] (any\[\n"]) * ["]    {RETURN(6);}
  76.  
  77.     "#"                  {RETURN(7);}
  78.     "&"                  {RETURN(8);}
  79.     "("                  {RETURN(9);}
  80.     ")"                  {RETURN(10);}
  81.     "*"                  {RETURN(11);}
  82.     "+"                  {RETURN(12);}
  83.     ","                  {RETURN(13);}
  84.     "-"                  {RETURN(14);}
  85.     "."                  {RETURN(15);}
  86.     ".."                 {RETURN(16);}
  87.     "/"                  {RETURN(17);}
  88.     ":"                  {RETURN(18);}
  89.     ":="                 {RETURN(19);}
  90.     ";"                  {RETURN(20);}
  91.     "<"                  {RETURN(21);}
  92.     "<="                 {RETURN(22);}
  93.     "<>"                 {RETURN(23);}
  94.     "="                  {RETURN(24);}
  95.     ">"                  {RETURN(25);}
  96.     ">="                 {RETURN(26);}
  97.     "["                  {RETURN(27);}
  98.     "]"                  {RETURN(28);}
  99.     "^"                  {RETURN(29);}
  100.     "{"                  {RETURN(30);}
  101.     "|"                  {RETURN(31);}
  102.     "}"                  {RETURN(32);}
  103.     "~"                  {RETURN(33);}
  104.  
  105.     "AND"                  {RETURN(34);}
  106.     "ARRAY"                {RETURN(35);}
  107.     "BEGIN"               {RETURN(36);}
  108.     "BY"                   {RETURN(37);}
  109.     "CASE"                 {RETURN(38);}
  110.     "CONST"                {RETURN(39);}
  111.     "DEFINITION"           {RETURN(40);}
  112.     "DIV"                  {RETURN(41);}
  113.     "DO"                   {RETURN(42);}
  114.     "ELSE"                 {RETURN(43);}
  115.     "ELSIF"                {RETURN(44);}
  116.     "END"                  {RETURN(45);}
  117.     "EXIT"                 {RETURN(46);}
  118.     "EXPORT"              {RETURN(47);}
  119.     "FOR"                  {RETURN(48);}
  120.     "FROM"                 {RETURN(49);}
  121.     "IF"                   {RETURN(50);}
  122.     "IMPLEMENTATION"       {RETURN(51);}
  123.     "IMPORT"               {RETURN(52);}
  124.     "IN"                   {RETURN(53);}
  125.     "LOOP"                 {RETURN(54);}
  126.     "MOD"                  {RETURN(55);}
  127.     "MODULE"               {RETURN(56);}
  128.     "NOT"                  {RETURN(57);}
  129.     "OF"                   {RETURN(58);}
  130.     "OR"                   {RETURN(59);}
  131.     "POINTER"              {RETURN(60);}
  132.     "PROCEDURE"            {RETURN(61);}
  133.     "QUALIFIED"            {RETURN(62);}
  134.     "RECORD"               {RETURN(63);}
  135.     "REPEAT"               {RETURN(64);}
  136.     "RETURN"               {RETURN(65);}
  137.     "SET"                  {RETURN(66);}
  138.     "THEN"                 {RETURN(67);}
  139.     "TO"                   {RETURN(68);}
  140.     "TYPE"                 {RETURN(69);}
  141.     "UNTIL"                {RETURN(70);}
  142.     "VAR"                  {RETURN(71);}
  143.     "WHILE"                {RETURN(72);}
  144.     "WITH"                 {RETURN(73);}
  145.  
  146.     letter (letter | digit) *    {RETURN(74);}
  147.  
  148.     [ \t]+            { goto std; }
  149.  
  150.     "\n"
  151.         {
  152.         if(cursor == s->eof) RETURN(0);
  153.         s->pos = cursor; s->line++;
  154.         goto std;
  155.         }
  156.  
  157.     any
  158.         {
  159.         printf("unexpected character: %c\n", *s->tok);
  160.         goto std;
  161.         }
  162. */
  163. comment:
  164. /*!re2c
  165.     "*)"
  166.         {
  167.         if(--depth == 0)
  168.             goto std;
  169.         else
  170.             goto comment;
  171.         }
  172.     "(*"            { ++depth; goto comment; }
  173.     "\n"
  174.         {
  175.         if(cursor == s->eof) RETURN(0);
  176.         s->tok = s->pos = cursor; s->line++;
  177.         goto comment;
  178.         }
  179.         any            { goto comment; }
  180. */
  181. }
  182.  
  183. /*
  184. void putStr(FILE *o, char *s, uint l){
  185.     while(l-- > 0)
  186.     putc(*s++, o);
  187. }
  188. */
  189.  
  190. main(){
  191.     Scanner in;
  192.     memset((char*) &in, 0, sizeof(in));
  193.     in.fd = 0;
  194.     while(scan(&in)){
  195. /*
  196.     putc('<', stdout);
  197.     putStr(stdout, (char*) in.tok, in.cur - in.tok);
  198.     putc('>', stdout);
  199.     putc('\n', stdout);
  200. */
  201.     }
  202. }
  203.